﻿#define _CRT_SECURE_NO_WARNINGS

//#include <stdio.h>
//#include <stdlib.h>

namespace bite1
{
	int rand = 0;

	int Add(int left, int right)
	{
		return (left + right) * 2;
	}
}

namespace bite2
{
	// 命名空间中可以定义变量/函数/类型
	int rand = 10;

	int Add(int left, int right)
	{
		return left + right;
	}

	struct Node
	{
		struct Node* next;
		int val;
	};
}

namespace bit
{
	// 命名空间中可以定义变量/函数/类型
	int a = 0;
	int b = 1;
	int Add(int left, int right)
	{
		return left + right;
	}
	struct Node
	{
		struct Node* next;
		int val;
	};
}

using namespace bit;
//int main()
//{
//	printf("%d\n",a);
//	printf("%d\n", Add(1,2));
//	Node node = { 0 };
//
//	return 0;
//}

//#include<iostream>
// std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中
//using namespace std;
//int main()
//{
//	//<< 流插入
//	int i = 0;
//	double j = 1.1;
//	//自动识别类型
//	cout << i << " " << j << endl;
//	//流提取
//	cin >> i >> j;
//	cout << i << " " << j << endl;
//	return 0;
//}

//void Func(int a = 1)
//{
//	cout << a << endl;
//}

//void Func(int a = 10, int b = 20, int c = 30)
//{
//	cout << "a = " << a << endl;
//	cout << "b = " << b << endl;
//	cout << "c = " << c << endl << endl;
//}

//void Func(int a, int b = 10, int c = 20)
//{
//	cout << "a = " << a << endl;
//	cout << "b = " << b << endl;
//	cout << "c = " << c << endl << endl;
//}

//#include <iostream>
//using namespace std;

//void Swap(int* pa, int* pb)
//{
//	cout << "void Swap(int* pa, int* pb)" << endl;
//}
//
//void Swap(double* pa, double* pb)
//{
//	cout << "void Swap(double* pa, double* pb)" << endl;
//}

//void f()
//{
//	cout << "f()" << endl;
//}
//
//void f(int a)
//{
//	cout << "f(int a)" << endl;
//}

//void f(int a, char b)
//{
//	cout << "f(int a,char b)" << endl;
//}
//
//void f(char b, int a)
//{
//	cout << "f(char b, int a)" << endl;
//}

//int main()
//{
//	f(1, 'a');
//	f('a', 1);
//	return 0;
//}

void Swap(int& px, int& py)
{
	int tmp = px;
	px = py;
	py = tmp;
}

//int main()
//{
//	/*int a = 3, b = 5;
//	Swap(a, b);
//	cout << a << " " << b << endl;*/
//
//	const int* b;
//
//	int a = 10;
//	int* p1 = &a;
//	int*& p2 = p1;
//	p2 = NULL;
//
//	return 0;
//
//}

//#include <stdlib.h>
//
//int main()
//{
//	perror("fail");
//	return 0;
//}

//#include <stdio.h>
//int main()
//{
//
//	//权限的平移
//	int x = 0;
//	int& y = x;
//
//	//权限的缩小,可以
//	const int& z = x;
//
//	//权限的放大
//	//m只读
//	//n变成m的别名,n的权限值可读可写
//	const int m = 0;
//	//int& n = m; // 该语句编译时会出错，n为常量
//	int* k = &m;
//
//	//权限的平移
//	const int& n = m;
//
//	//可以,不是权限的放大
//	//m拷贝给p,p的修改不影响m
//	int p = m;
//
//	//权限的放大
//	//p1可以修改,*p1不可以,const修饰的是p1
//	const int* p1 = &m;
//	//int* p2 = p1;  //err
//	const int* p2 = p1;
//	return 0;
//}

//#include <stdio.h>
//int main()
//{
//	int* p = NULL;
//	int& q = *p;
//	*p;	
//	return 0;
//}

#include <iostream>
using namespace std;

//void f(int)
//{
//	cout << "f(int)" << endl;
//}
//void f(double*)
//{
//	cout << "f(int*)" << endl;
//}
//int main()
//{
//	f(0);
//	//f(NULL);
//	//f((int*)NULL);
//	f(nullptr);
//	//f((void*)NULL);
//	return 0;
//}

//类里面会全局搜索，不需要变量定义在函数前面
//struct Stack
//{
//	//成员函数
//	void Init(int n = 4)
//	{
//		a = (int*)malloc(sizeof(int) * n);
//		if (a == nullptr)
//		{
//			perror("malloc fail");
//			return;
//		}
//
//		capacity = n;
//		size = 0;
//	}
//
////	void Push(int x)
////	{
////		//...
////		//检查扩容
////		a[size++] = x;
////	}
//
//	//成员变量
//	int* a;
//	int size;
//	int capacity;
//};

struct Stack
{
	// 成员函数
	void Init(int n = 4)
	{
		array = (int*)malloc(sizeof(int) * n);
		if (nullptr == array)
		{
			perror("malloc申请空间失败");
			return;
		}

		capacity = n;
		top = 0;
	}

	//void Push(int x)
	//{
	//	// ...扩容
	//	array[top++] = x;
	//}

	void Push(int x)
	{
		//...
		//检查扩容
		array[top++] = x;
	}

	// 成员变量
	int* array;
	size_t capacity;
	size_t top;
};

int main()
{
	Stack st;
	st.Init();
	st.Push(1);
	st.Push(2);
	st.Push(3);

	return 0;
}